## Erste Schritte mit PyTorch

Schritt 1:Umgebungseinrichtung

* Installieren Sie Python und erstellen Sie eine virtuelle Umgebung

- Python 3.6 oder höher wird empfohlen.

- Erstellen Sie eine virtuelle Umgebung mit „python -m venv venv“ (oder „virtualenv venv“ für ältere Python-Versionen) und aktivieren Sie sie mit „source venv/bin/activate“ unter Linux/macOS oder „venv\Scripts\activate“ unter Windows .

* PyTorch installieren

- Verwenden Sie „pip“, um PyTorch zu installieren:„pip install Torch Torchvision“.

- Für GPU-Unterstützung installieren Sie „torch“ mit der Option „-c pytorch“.

Schritt 2:Einfaches Beispiel – Erstellen eines Tensors

„Python

Taschenlampe importieren

Erstellen Sie einen Tensor aus einer Liste

tensor =Torch.tensor([1, 2, 3])

Drucken Sie den Tensor

print(tensor)

Drucken Sie die Form des Tensors

print(tensor.shape)

Drucken Sie den Typ des Tensors

print(tensor.dtype)

„

Ausgabe:

„

Tensor([1, 2, 3])

Torch.Size([3])

Torch.int64

„

Schritt 3:Grundlegende mathematische Operationen

„Python

Elementweise Addition

tensor =Torch.tensor([1, 2, 3])

tensor2 =Torch.tensor([4, 5, 6])

Ergebnis =Tensor + Tensor2

drucken(Ergebnis)

Ausgabe:tensor([ 5, 7, 9])

Matrixmultiplikation

Matrix1 =Torch.tensor([[1, 2], [3, 4]])

Matrix2 =Torch.tensor([[5, 6], [7, 8]])

Ergebnis =Torch.mm(Matrix1, Matrix2)

drucken(Ergebnis)

Ausgabe:tensor([[19, 22], [43, 50]])

„

Schritt 4:GPU für schnellere Berechnungen verwenden

„Python

Überprüfen Sie, ob CUDA verfügbar ist

wenn Torch.cuda.is_available():

# Verschieben Sie die Tensoren auf die GPU

device =Torch.device("cuda")

tensor =tensor.to(device)

tensor2 =tensor2.to(Gerät)

# Führen Sie Vorgänge auf der GPU aus

Ergebnis =Tensor + Tensor2

# Verschieben Sie das Ergebnis bei Bedarf zurück zur CPU

result =result.to("cpu")

drucken(Ergebnis)

„

Arbeiten mit Daten

Schritt 1:Datensatz

PyTorch bietet mithilfe seiner Klasse „Dataset“ eine bequeme Möglichkeit, mit Datensätzen zu arbeiten. Hier ist ein Beispiel:

„Python

Klasse MyDataset(torch.utils.data.Dataset):

def __init__(self, data, labels):

self.data =Daten

self.labels =Etiketten

def __getitem__(self, index):

return self.data[index], self.labels[index]

def __len__(self):

return len(self.data)

Erstellen Sie eine Instanz des Datensatzes

dataset =MyDataset(data, labels)

„

Schritt 2:DataLoader

Verwenden Sie „DataLoader“, um Daten während des Trainings effizient stapelweise zu laden.

„Python

Stapelgröße definieren

Batch_size =32

Erstellen Sie einen Datenlader

data_loader =Torch.utils.data.DataLoader(Datensatz, Batch_size=Batch_size)

Durchlaufen Sie die Stapel

für Batch in data_loader:

# Hier wäre Batch ein Tupel von „(Daten, Etiketten)“.

„

Aufbau eines neuronalen Netzwerks

Schritt 1:Initialisieren Sie Ihr Netzwerk

„Python

importiere Torch.nn als nn

Definieren Sie ein einfaches neuronales Netzwerk mit 3 Schichten

Klasse MyNeuralNetwork(nn.Module):

def __init__(self):

super(MyNeuralNetwork, self).__init__()

self.layer1 =nn.Linear(784, 256) # Eingabeebene

self.layer2 =nn.Linear(256, 128) # Versteckte Ebene

self.layer3 =nn.Linear(128, 10) # Ausgabeebene

def vorwärts(selbst, x):

x =x.view(x.shape[0], -1) # Eingabe reduzieren

x =F.relu(self.layer1(x)) # Aktivierungsfunktion (ReLU)

x =F.relu(self.layer2(x)) # Aktivierungsfunktion (ReLU)

x =F.log_softmax(self.layer3(x)) # Ausgabeebene mit Softmax

x zurückgeben

Initialisieren Sie das Netzwerk

network =MyNeuralNetwork()

„

Schritt 2:Verlustfunktion und Optimierer definieren

„Python

importiere Torch.optim als optim

Verlustfunktion definieren (hier verwenden wir Kreuzentropieverlust)

loss_fn =nn.CrossEntropyLoss()

Optimierer definieren (hier verwenden wir den stochastischen Gradientenabstieg)

Optimizer =optim.SGD(network.parameters(), lr=0.001)

„

Schritt 3:Trainieren Sie das Netzwerk

„Python

Trainieren Sie das Netzwerk für 10 Epochen

für Epoche im Bereich(10):

für Batch in data_loader:

# Eingaben und Beschriftungen abrufen

Eingaben, Etiketten =Batch

# Klare Farbverläufe

optimierer.zero_grad()

# Vorwärtspass

Ausgänge =Netzwerk(Eingänge)

# Rechenverlust

loss =loss_fn(Ausgaben, Labels)

# Rückwärtsdurchlauf und Aktualisierung der Gewichte

loss.backward()

optimierer.step()

print(f"Epoche {epoch + 1}:Verlust:{loss.item()}")

„

Schritt 4:Bewerten Sie das Netzwerk

„Python

Bewerten Sie die Netzwerkgenauigkeit anhand des Testdatensatzes

mit Torch.no_grad():

richtig =0

Gesamt =0

für Batch in test_data_loader:

Eingaben, Etiketten =Batch

# Vorwärtspass

Ausgänge =Netzwerk(Eingänge)

# Vorhersagen abrufen

_, vorhergesagt =Torch.max(outputs.data, 1)

# Genauigkeitsanzahl aktualisieren

insgesamt +=labels.size(0)

richtig +=(vorhergesagt ==Etiketten).sum().item()

# Genauigkeit berechnen

Genauigkeit =richtig / gesamt

print(f"Genauigkeit der Testdaten:{Genauigkeit * 100}%")

„